Termination w.r.t. Q of the following Term Rewriting System could be proven:

Q restricted rewrite system:
The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.


QTRS
  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

EQ2(var1(l), var1(l')) -> EQ2(l, l')
REN3(x, y, apply2(t, s)) -> REN3(x, y, t)
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(x, x')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> AND2(eq2(t, t'), eq2(s, s'))
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(t, t')
REN3(var1(l), var1(k), var1(l')) -> EQ2(l, l')
EQ2(lambda2(x, t), lambda2(x', t')) -> AND2(eq2(x, x'), eq2(t, t'))
EQ2(cons2(t, l), cons2(t', l')) -> AND2(eq2(t, t'), eq2(l, l'))
REN3(x, y, lambda2(z, t)) -> REN3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t))
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(t, t')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')
REN3(var1(l), var1(k), var1(l')) -> IF3(eq2(l, l'), var1(k), var1(l'))
REN3(x, y, lambda2(z, t)) -> REN3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)
REN3(x, y, apply2(t, s)) -> REN3(x, y, s)

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ DependencyPairsProof
QDP
      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

EQ2(var1(l), var1(l')) -> EQ2(l, l')
REN3(x, y, apply2(t, s)) -> REN3(x, y, t)
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(x, x')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> AND2(eq2(t, t'), eq2(s, s'))
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(t, t')
REN3(var1(l), var1(k), var1(l')) -> EQ2(l, l')
EQ2(lambda2(x, t), lambda2(x', t')) -> AND2(eq2(x, x'), eq2(t, t'))
EQ2(cons2(t, l), cons2(t', l')) -> AND2(eq2(t, t'), eq2(l, l'))
REN3(x, y, lambda2(z, t)) -> REN3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t))
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(t, t')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')
REN3(var1(l), var1(k), var1(l')) -> IF3(eq2(l, l'), var1(k), var1(l'))
REN3(x, y, lambda2(z, t)) -> REN3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)
REN3(x, y, apply2(t, s)) -> REN3(x, y, s)

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 2 SCCs with 5 less nodes.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
QDP
            ↳ QDPOrderProof
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ2(var1(l), var1(l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(x, x')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(l, l')
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(t, t')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(t, t')

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


EQ2(var1(l), var1(l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(t, t')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(l, l')
EQ2(apply2(t, s), apply2(t', s')) -> EQ2(s, s')
EQ2(cons2(t, l), cons2(t', l')) -> EQ2(t, t')
The remaining pairs can at least be oriented weakly.

EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(x, x')
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(t, t')
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( var1(x1) ) = x1 + 1


POL( EQ2(x1, x2) ) = x1


POL( cons2(x1, x2) ) = x1 + x2 + 1


POL( lambda2(x1, x2) ) = x1 + x2


POL( apply2(x1, x2) ) = x1 + x2 + 1



The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ QDPOrderProof
          ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(x, x')
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(t, t')

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(x, x')
EQ2(lambda2(x, t), lambda2(x', t')) -> EQ2(t, t')
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( lambda2(x1, x2) ) = x1 + x2 + 1


POL( EQ2(x1, x2) ) = x1



The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
QDP
                    ↳ PisEmptyProof
          ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
QDP
            ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

REN3(x, y, apply2(t, s)) -> REN3(x, y, t)
REN3(x, y, lambda2(z, t)) -> REN3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t))
REN3(x, y, lambda2(z, t)) -> REN3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)
REN3(x, y, apply2(t, s)) -> REN3(x, y, s)

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


REN3(x, y, lambda2(z, t)) -> REN3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t))
REN3(x, y, lambda2(z, t)) -> REN3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)
The remaining pairs can at least be oriented weakly.

REN3(x, y, apply2(t, s)) -> REN3(x, y, t)
REN3(x, y, apply2(t, s)) -> REN3(x, y, s)
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( var1(x1) ) = max{0, -1}


POL( true ) = max{0, -1}


POL( if3(x1, ..., x3) ) = max{0, x3 - 1}


POL( and2(x1, x2) ) = max{0, -1}


POL( ren3(x1, ..., x3) ) = x3


POL( false ) = max{0, -1}


POL( lambda2(x1, x2) ) = x2 + 1


POL( eq2(x1, x2) ) = max{0, -1}


POL( REN3(x1, ..., x3) ) = x3


POL( nil ) = max{0, -1}


POL( cons2(x1, x2) ) = max{0, -1}


POL( apply2(x1, x2) ) = x1 + x2



The following usable rules [14] were oriented:

ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))
if3(false, var1(k), var1(l')) -> var1(l')
if3(true, var1(k), var1(l')) -> var1(k)



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
QDP
                ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

REN3(x, y, apply2(t, s)) -> REN3(x, y, t)
REN3(x, y, apply2(t, s)) -> REN3(x, y, s)

The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].


The following pairs can be oriented strictly and are deleted.


REN3(x, y, apply2(t, s)) -> REN3(x, y, t)
REN3(x, y, apply2(t, s)) -> REN3(x, y, s)
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial Order [17,21] with Interpretation:

POL( REN3(x1, ..., x3) ) = x3 + 1


POL( apply2(x1, x2) ) = x1 + x2 + 1



The following usable rules [14] were oriented: none



↳ QTRS
  ↳ DependencyPairsProof
    ↳ QDP
      ↳ DependencyGraphProof
        ↳ AND
          ↳ QDP
          ↳ QDP
            ↳ QDPOrderProof
              ↳ QDP
                ↳ QDPOrderProof
QDP
                    ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

and2(true, y) -> y
and2(false, y) -> false
eq2(nil, nil) -> true
eq2(cons2(t, l), nil) -> false
eq2(nil, cons2(t, l)) -> false
eq2(cons2(t, l), cons2(t', l')) -> and2(eq2(t, t'), eq2(l, l'))
eq2(var1(l), var1(l')) -> eq2(l, l')
eq2(var1(l), apply2(t, s)) -> false
eq2(var1(l), lambda2(x, t)) -> false
eq2(apply2(t, s), var1(l)) -> false
eq2(apply2(t, s), apply2(t', s')) -> and2(eq2(t, t'), eq2(s, s'))
eq2(apply2(t, s), lambda2(x, t)) -> false
eq2(lambda2(x, t), var1(l)) -> false
eq2(lambda2(x, t), apply2(t, s)) -> false
eq2(lambda2(x, t), lambda2(x', t')) -> and2(eq2(x, x'), eq2(t, t'))
if3(true, var1(k), var1(l')) -> var1(k)
if3(false, var1(k), var1(l')) -> var1(l')
ren3(var1(l), var1(k), var1(l')) -> if3(eq2(l, l'), var1(k), var1(l'))
ren3(x, y, apply2(t, s)) -> apply2(ren3(x, y, t), ren3(x, y, s))
ren3(x, y, lambda2(z, t)) -> lambda2(var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), ren3(x, y, ren3(z, var1(cons2(x, cons2(y, cons2(lambda2(z, t), nil)))), t)))

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.